use rusqlite::Row;

/// 公告表对应的数据模型结构体
/// 
/// 用于存储土地交易公告的基本信息
#[derive(Debug, Clone)]
pub struct Notice {
    /// 公告ID，作为主键
    pub notice_id: String,
    /// 公告日期，格式为"YYYY-MM-DD HH:MM:SS"
    pub notice_date: String,
    /// 公告区县
    pub area: String,
    /// 公告文号
    pub identifier: String,
    /// 公告名称
    pub notice_name: String,
}

/// 交易表对应的数据模型结构体
/// 
/// 用于存储土地交易的详细信息
#[derive(Debug, Clone)]
pub struct Target {
    /// 交易ID，作为主键
    pub target_id: String,
    /// 公告ID，关联notice_table
    pub notice_id: String,
    /// 交易状态码: 5已成交，6流拍，4交易中/终止，7待审核，3已公告
    pub status: Option<i32>,
    /// 是否终止交易: 1终止交易，0未终止交易
    pub is_stop: Option<i32>,
    /// 竞得人名称
    pub trans_bidder: Option<String>,
    /// 成交日期，格式为"YYYY-MM-DD HH:MM:SS"
    pub end_trans_time: Option<String>,
    /// 交易总成交价（万元）
    pub trans_price: Option<f32>,
    /// 交易地上成交价
    pub trans_price_above: Option<f32>,
    /// 交易地下成交价
    pub trans_price_under: Option<f32>,
    /// 增价幅度（万元）
    pub price_step: Option<f32>,
    /// 交易总起拍价（万元）
    pub begin_price: Option<f32>,
    /// 交易地上起拍价
    pub begin_price_above: Option<f32>,
    /// 交易地下起拍价
    pub begin_price_under: Option<f32>,
    /// 公告序号
    pub notice_xh: Option<String>,
    /// 挂牌开始时间，格式为"YYYY-MM-DD HH:MM:SS"
    pub begin_focus_time: Option<String>,
    /// 挂牌结束时间，格式为"YYYY-MM-DD HH:MM:SS"
    pub end_focus_time: Option<String>,
    /// 申请竞买开始时间，格式为"YYYY-MM-DD HH:MM:SS"
    pub begin_apply_time: Option<String>,
    /// 申请竞买结束时间，格式为"YYYY-MM-DD HH:MM:SS"
    pub end_apply_time: Option<String>,
}

/// 区县表对应的数据模型结构体
/// 
/// 用于存储区县及机构信息
#[derive(Debug, Clone)]
pub struct Canton {
    /// 自增主键ID
    pub id: Option<u64>,
    /// 区县ID
    pub canton_id: String,
    /// 区县名称
    pub canton_name: Option<String>,
    /// 机构ID
    pub organ_id: Option<String>,
    /// 机构名称
    pub orgen_name: Option<String>,
}

/// 为Canton实现FromRow特性，方便从数据库查询结果转换
impl<'a> From<&Row<'a>> for Canton {
    /// 从数据库行创建Canton对象
    fn from(row: &Row<'a>) -> Self {
        Self {
            id: row.get(0).unwrap_or(None),
            canton_id: row.get(1).unwrap_or_default(),
            canton_name: row.get(2).unwrap_or(None),
            organ_id: row.get(3).unwrap_or(None),
            orgen_name: row.get(4).unwrap_or(None),
        }
    }
}

/// 宗地表对应的数据模型结构体
/// 
/// 用于存储具体宗地的详细信息
#[derive(Debug, Clone)]
pub struct Goods {
    /// 宗地ID，作为主键
    pub goods_id: String,
    /// 交易ID，关联target_table
    pub target_id: String,
    /// 交易类别
    pub business_name: Option<String>,
    /// 宗地编号
    pub goods_no: Option<String>,
    /// 宗地名称
    pub goods_name: Option<String>,
    /// 宗地面积
    pub land_area: Option<f32>,
    /// 土地用途
    pub goods_use: Option<String>,
    /// 出让年期
    pub use_years: Option<String>,
    /// 位置信息
    pub address: Option<String>,
    /// 宗地总起拍价
    pub goods_begin_price: Option<f32>,
    /// 宗地地上起拍价
    pub goods_begin_price_above: Option<f32>,
    /// 宗地地下起拍价
    pub goods_begin_price_under: Option<f32>,
    /// 宗地总成交价（万元）
    pub trans_goods_price: Option<f32>,
    /// 宗地地上成交价
    pub trans_goods_price_above: Option<f32>,
    /// 宗地地下成交价
    pub trans_goods_price_under: Option<f32>,
    /// 地上容积率下限
    pub plot1_down: Option<String>,
    /// 地上容积率下限标志
    pub plot1_flag: Option<String>,
    /// 地上容积率上限
    pub plot1_up: Option<String>,
    /// 地上容积率上限标志
    pub plot1_flag2: Option<String>,
    /// 地下容积率下限
    pub plot2_down: Option<String>,
    /// 地下容积率下限标志
    pub plot2_flag: Option<String>,
    /// 地下容积率上限
    pub plot2_up: Option<String>,
    /// 地下容积率上限标志
    pub plot2_flag2: Option<String>,
    /// 建筑密度下限
    pub build_density_down: Option<String>,
    /// 建筑密度下限标志
    pub build_density_flag: Option<String>,
    /// 建筑密度上限
    pub build_density_up: Option<String>,
    /// 建筑密度上限标志
    pub build_density_flag2: Option<String>,
    /// 建筑高度
    pub ild_height: Option<String>,
    /// 绿地率下限
    pub green_ratio_down: Option<String>,
    /// 绿地率下限标志
    pub green_ratio_flag: Option<String>,
    /// 绿地率上限
    pub green_ratio_up: Option<String>,
    /// 绿地率上限标志
    pub green_ratio_flag2: Option<String>,
    /// 其他说明
    pub remark: Option<String>,
    /// 其他条件
    pub other_condition: Option<String>,
    /// 必要条件
    pub start_required: Option<String>,
    /// 保证金
    pub deposit_price: Option<String>,
    /// 加价幅度（万元）
    pub price_step: Option<f32>,
    /// 出让金预交款
    pub crj_yjk: Option<f32>,
    /// 允许联合竞买: 1允许，0不允许
    pub allow_union: Option<i32>,
    /// 本宗地占交易价格比例
    pub percent_price: Option<f32>,
    /// 开发强度
    pub develop: Option<String>,
}

/// 为Notice实现FromRow特性，方便从数据库查询结果转换
impl<'a> From<&Row<'a>> for Notice {
    /// 从数据库行创建Notice对象
    /// 
    /// 注意：使用unwrap()假设数据库查询结果中字段顺序正确且非空
    fn from(row: &Row<'a>) -> Self {
        Self {
            notice_id: row.get(0).unwrap_or_default(),
            notice_date: row.get(1).unwrap_or_default(),
            area: row.get(2).unwrap_or_default(),
            identifier: row.get(3).unwrap_or_default(),
            notice_name: row.get(4).unwrap_or_default(),
        }
    }
}

/// 为Target实现FromRow特性，方便从数据库查询结果转换
impl<'a> From<&Row<'a>> for Target {
    /// 从数据库行创建Target对象
    /// 
    /// 使用unwrap()处理可空字段，实际应用中应考虑更健壮的错误处理
    fn from(row: &Row<'a>) -> Self {
        Self {
            target_id: row.get(0).unwrap_or_default(),
            notice_id: row.get(1).unwrap_or_default(),
            status: row.get(2).unwrap_or(None),
            is_stop: row.get(3).unwrap_or(None),
            trans_bidder: row.get(4).unwrap_or(None),
            end_trans_time: row.get(5).unwrap_or(None),
            trans_price: row.get(6).unwrap_or(None),
            trans_price_above: row.get(7).unwrap_or(None),
            trans_price_under: row.get(8).unwrap_or(None),
            price_step: row.get(9).unwrap_or(None),
            begin_price: row.get(10).unwrap_or(None),
            begin_price_above: row.get(11).unwrap_or(None),
            begin_price_under: row.get(12).unwrap_or(None),
            notice_xh: row.get(13).unwrap_or(None),
            begin_focus_time: row.get(14).unwrap_or(None),
            end_focus_time: row.get(15).unwrap_or(None),
            begin_apply_time: row.get(16).unwrap_or(None),
            end_apply_time: row.get(17).unwrap_or(None),
        }
    }
}

/// 为Goods实现FromRow特性，方便从数据库查询结果转换
impl<'a> From<&Row<'a>> for Goods {
    /// 从数据库行创建Goods对象
    /// 
    /// 使用unwrap()处理所有字段，实际应用中应考虑更健壮的错误处理
    fn from(row: &Row<'a>) -> Self {
        Self {
            goods_id: row.get(0).unwrap_or_default(),
            target_id: row.get(1).unwrap_or_default(),
            business_name: row.get(2).unwrap_or(None),
            goods_no: row.get(3).unwrap_or(None),
            goods_name: row.get(4).unwrap_or(None),
            land_area: row.get(5).unwrap_or(None),
            goods_use: row.get(6).unwrap_or(None),
            use_years: row.get(7).unwrap_or(None),
            address: row.get(8).unwrap_or(None),
            goods_begin_price: row.get(9).unwrap_or(None),
            goods_begin_price_above: row.get(10).unwrap_or(None),
            goods_begin_price_under: row.get(11).unwrap_or(None),
            trans_goods_price: row.get(12).unwrap_or(None),
            trans_goods_price_above: row.get(13).unwrap_or(None),
            trans_goods_price_under: row.get(14).unwrap_or(None),
            plot1_down: row.get(15).unwrap_or(None),
            plot1_flag: row.get(16).unwrap_or(None),
            plot1_up: row.get(17).unwrap_or(None),
            plot1_flag2: row.get(18).unwrap_or(None),
            plot2_down: row.get(19).unwrap_or(None),
            plot2_flag: row.get(20).unwrap_or(None),
            plot2_up: row.get(21).unwrap_or(None),
            plot2_flag2: row.get(22).unwrap_or(None),
            build_density_down: row.get(23).unwrap_or(None),
            build_density_flag: row.get(24).unwrap_or(None),
            build_density_up: row.get(25).unwrap_or(None),
            build_density_flag2: row.get(26).unwrap_or(None),
            ild_height: row.get(27).unwrap_or(None),
            green_ratio_down: row.get(28).unwrap_or(None),
            green_ratio_flag: row.get(29).unwrap_or(None),
            green_ratio_up: row.get(30).unwrap_or(None),
            green_ratio_flag2: row.get(31).unwrap_or(None),
            remark: row.get(32).unwrap_or(None),
            other_condition: row.get(33).unwrap_or(None),
            start_required: row.get(34).unwrap_or(None),
            deposit_price: row.get(35).unwrap_or(None),
            price_step: row.get(36).unwrap_or(None),
            crj_yjk: row.get(37).unwrap_or(None),
            allow_union: row.get(38).unwrap_or(None),
            percent_price: row.get(39).unwrap_or(None),
            develop: row.get(40).unwrap_or(None),
        }
    }
}